using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("NetCache")]
	public class NetCache : MonoClass
	{
		[Attribute38("NetCache.NetCacheGamesPlayed")]
		public class NetCacheGamesPlayed : MonoClass
		{
			public int GamesStarted => method_11<int>("get_GamesStarted", Array.Empty<object>());

			public int GamesWon => method_11<int>("get_GamesWon", Array.Empty<object>());

			public int GamesLost => method_11<int>("get_GamesLost", Array.Empty<object>());

			public int FreeRewardProgress => method_11<int>("get_FreeRewardProgress", Array.Empty<object>());

			public NetCacheGamesPlayed(IntPtr address, string className)
				: base(address, className)
			{
			}

			public NetCacheGamesPlayed(IntPtr address)
				: this(address, "NetCacheGamesPlayed")
			{
			}
		}

		[Attribute38("NetCache.NetCacheFeatures")]
		public class NetCacheFeatures : MonoClass
		{
			[Attribute38("NetCache.NetCacheFeatures.CacheMisc")]
			public class CacheMisc : MonoClass
			{
				public int ClientOptionsUpdateIntervalSeconds => method_11<int>("get_ClientOptionsUpdateIntervalSeconds", Array.Empty<object>());

				public CacheMisc(IntPtr address, string className)
					: base(address, className)
				{
				}

				public CacheMisc(IntPtr address)
					: this(address, "CacheMisc")
				{
				}
			}

			[Attribute38("NetCache.NetCacheFeatures.CacheGames")]
			public class CacheGames : MonoClass
			{
				public bool Tournament => method_11<bool>("get_Tournament", Array.Empty<object>());

				public bool Practice => method_11<bool>("get_Practice", Array.Empty<object>());

				public bool Casual => method_11<bool>("get_Casual", Array.Empty<object>());

				public bool Forge => method_11<bool>("get_Forge", Array.Empty<object>());

				public bool Friendly => method_11<bool>("get_Friendly", Array.Empty<object>());

				public bool TavernBrawl => method_11<bool>("get_TavernBrawl", Array.Empty<object>());

				public int ShowUserUI => method_11<int>("get_ShowUserUI", Array.Empty<object>());

				public CacheGames(IntPtr address, string className)
					: base(address, className)
				{
				}

				public CacheGames(IntPtr address)
					: this(address, "CacheGames")
				{
				}
			}

			[Attribute38("NetCache.NetCacheFeatures.CacheCollection")]
			public class CacheCollection : MonoClass
			{
				public bool Manager => method_11<bool>("get_Manager", Array.Empty<object>());

				public bool Crafting => method_11<bool>("get_Crafting", Array.Empty<object>());

				public CacheCollection(IntPtr address, string className)
					: base(address, className)
				{
				}

				public CacheCollection(IntPtr address)
					: this(address, "CacheCollection")
				{
				}
			}

			[Attribute38("NetCache.NetCacheFeatures.CacheStore")]
			public class CacheStore : MonoClass
			{
				public bool Store => method_11<bool>("get_Store", Array.Empty<object>());

				public bool BattlePay => method_11<bool>("get_BattlePay", Array.Empty<object>());

				public bool BuyWithGold => method_11<bool>("get_BuyWithGold", Array.Empty<object>());

				public CacheStore(IntPtr address, string className)
					: base(address, className)
				{
				}

				public CacheStore(IntPtr address)
					: this(address, "CacheStore")
				{
				}
			}

			[Attribute38("NetCache.NetCacheFeatures.CacheHeroes")]
			public class CacheHeroes : MonoClass
			{
				public bool Hunter => method_11<bool>("get_Hunter", Array.Empty<object>());

				public bool Mage => method_11<bool>("get_Mage", Array.Empty<object>());

				public bool Paladin => method_11<bool>("get_Paladin", Array.Empty<object>());

				public bool Priest => method_11<bool>("get_Priest", Array.Empty<object>());

				public bool Rogue => method_11<bool>("get_Rogue", Array.Empty<object>());

				public bool Shaman => method_11<bool>("get_Shaman", Array.Empty<object>());

				public bool Warlock => method_11<bool>("get_Warlock", Array.Empty<object>());

				public bool Warrior => method_11<bool>("get_Warrior", Array.Empty<object>());

				public CacheHeroes(IntPtr address, string className)
					: base(address, className)
				{
				}

				public CacheHeroes(IntPtr address)
					: this(address, "CacheHeroes")
				{
				}
			}

			public bool CaisEnabledNonMobile => method_2<bool>("CaisEnabledNonMobile");

			public bool CaisEnabledMobileChina => method_2<bool>("CaisEnabledMobileChina");

			public bool CaisEnabledMobileSouthKorea => method_2<bool>("CaisEnabledMobileSouthKorea");

			public bool SendTelemetryPresence => method_2<bool>("SendTelemetryPresence");

			public CacheMisc Misc => method_14<CacheMisc>("get_Misc", Array.Empty<object>());

			public CacheGames Games => method_14<CacheGames>("get_Games", Array.Empty<object>());

			public CacheCollection Collection => method_14<CacheCollection>("get_Collection", Array.Empty<object>());

			public CacheStore Store => method_14<CacheStore>("get_Store", Array.Empty<object>());

			public CacheHeroes Heroes => method_14<CacheHeroes>("get_Heroes", Array.Empty<object>());

			public int WinsPerGold => method_11<int>("get_WinsPerGold", Array.Empty<object>());

			public int GoldPerReward => method_11<int>("get_GoldPerReward", Array.Empty<object>());

			public int MaxGoldPerDay => method_11<int>("get_MaxGoldPerDay", Array.Empty<object>());

			public int XPSoloLimit => method_11<int>("get_XPSoloLimit", Array.Empty<object>());

			public int MaxHeroLevel => method_11<int>("get_MaxHeroLevel", Array.Empty<object>());

			public float SpecialEventTimingMod => method_11<float>("get_SpecialEventTimingMod", Array.Empty<object>());

			public int FriendWeekConcederMaxDefense => method_11<int>("get_FriendWeekConcederMaxDefense", Array.Empty<object>());

			public int FriendWeekConcededGameMinTotalTurns => method_11<int>("get_FriendWeekConcededGameMinTotalTurns", Array.Empty<object>());

			public bool FriendWeekAllowsTavernBrawlRecordUpdate => method_11<bool>("get_FriendWeekAllowsTavernBrawlRecordUpdate", Array.Empty<object>());

			public bool FSGEnabled => method_11<bool>("get_FSGEnabled", Array.Empty<object>());

			public bool FSGAutoCheckinEnabled => method_11<bool>("get_FSGAutoCheckinEnabled", Array.Empty<object>());

			public bool FSGLoginScanEnabled => method_11<bool>("get_FSGLoginScanEnabled", Array.Empty<object>());

			public bool FSGShowBetaLabel => method_11<bool>("get_FSGShowBetaLabel", Array.Empty<object>());

			public int FSGFriendListPatronCountLimit => method_11<int>("get_FSGFriendListPatronCountLimit", Array.Empty<object>());

			public uint ArenaClosedToNewSessionsSeconds => method_11<uint>("get_ArenaClosedToNewSessionsSeconds", Array.Empty<object>());

			public NetCacheFeatures(IntPtr address, string className)
				: base(address, className)
			{
			}

			public NetCacheFeatures(IntPtr address)
				: this(address, "NetCacheFeatures")
			{
			}
		}

		[Attribute38("NetCache.NetCacheArcaneDustBalance")]
		public class NetCacheArcaneDustBalance : MonoClass
		{
			public long Balance => method_11<long>("get_Balance", Array.Empty<object>());

			public NetCacheArcaneDustBalance(IntPtr address, string className)
				: base(address, className)
			{
			}

			public NetCacheArcaneDustBalance(IntPtr address)
				: this(address, "NetCacheArcaneDustBalance")
			{
			}
		}

		[Attribute38("NetCache.NetCacheGoldBalance")]
		public class NetCacheGoldBalance : MonoClass
		{
			public long CappedBalance => method_11<long>("get_CappedBalance", Array.Empty<object>());

			public long BonusBalance => method_11<long>("get_BonusBalance", Array.Empty<object>());

			public long Cap => method_11<long>("get_Cap", Array.Empty<object>());

			public long CapWarning => method_11<long>("get_CapWarning", Array.Empty<object>());

			public NetCacheGoldBalance(IntPtr address, string className)
				: base(address, className)
			{
			}

			public NetCacheGoldBalance(IntPtr address)
				: this(address, "NetCacheGoldBalance")
			{
			}

			public long GetTotal()
			{
				return method_11<long>("GetTotal", Array.Empty<object>());
			}
		}

		[Attribute38("NetCache.NetCacheSubscribeResponse")]
		public class NetCacheSubscribeResponse : MonoClass
		{
			public ulong FeaturesSupported => method_2<ulong>("FeaturesSupported");

			public ulong Route => method_2<ulong>("Route");

			public ulong KeepAliveDelay => method_2<ulong>("KeepAliveDelay");

			public ulong RequestMaxWaitSecs => method_2<ulong>("RequestMaxWaitSecs");

			public NetCacheSubscribeResponse(IntPtr address, string className)
				: base(address, className)
			{
			}

			public NetCacheSubscribeResponse(IntPtr address)
				: this(address, "NetCacheSubscribeResponse")
			{
			}
		}

		[Attribute38("NetCache.NetCachePlayQueue")]
		public class NetCachePlayQueue : MonoClass
		{
			public NetCachePlayQueue(IntPtr address, string className)
				: base(address, className)
			{
			}

			public NetCachePlayQueue(IntPtr address)
				: this(address, "NetCachePlayQueue")
			{
			}
		}

		[Attribute38("NetCache.HeroLevel")]
		public class HeroLevel : MonoClass
		{
			[Attribute38("NetCache.HeroLevel.NextLevelReward")]
			public class NextLevelReward : MonoClass
			{
				public int Level => method_11<int>("get_Level", Array.Empty<object>());

				public RewardData Reward => method_14<RewardData>("get_Reward", Array.Empty<object>());

				public NextLevelReward(IntPtr address, string className)
					: base(address, className)
				{
				}

				public NextLevelReward(IntPtr address)
					: this(address, "NextLevelReward")
				{
				}

				public new string ToString()
				{
					return method_13("ToString");
				}
			}

			[Attribute38("NetCache.HeroLevel.LevelInfo")]
			public class LevelInfo : MonoClass
			{
				public int Level => method_11<int>("get_Level", Array.Empty<object>());

				public int MaxLevel => method_11<int>("get_MaxLevel", Array.Empty<object>());

				public long XP => method_11<long>("get_XP", Array.Empty<object>());

				public long MaxXP => method_11<long>("get_MaxXP", Array.Empty<object>());

				public LevelInfo(IntPtr address, string className)
					: base(address, className)
				{
				}

				public LevelInfo(IntPtr address)
					: this(address, "LevelInfo")
				{
				}

				public bool IsMaxLevel()
				{
					return method_11<bool>("IsMaxLevel", Array.Empty<object>());
				}

				public new string ToString()
				{
					return method_13("ToString");
				}
			}

			public TAG_CLASS Class => method_11<TAG_CLASS>("get_Class", Array.Empty<object>());

			public LevelInfo PrevLevel => method_14<LevelInfo>("get_PrevLevel", Array.Empty<object>());

			public LevelInfo CurrentLevel => method_14<LevelInfo>("get_CurrentLevel", Array.Empty<object>());

			public NextLevelReward NextReward => method_14<NextLevelReward>("get_NextReward", Array.Empty<object>());

			public HeroLevel(IntPtr address, string className)
				: base(address, className)
			{
			}

			public HeroLevel(IntPtr address)
				: this(address, "HeroLevel")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("NetCache.NetCacheHeroLevels")]
		public class NetCacheHeroLevels : MonoClass
		{
			public List<HeroLevel> Levels => method_14<Class271<HeroLevel>>("get_Levels", Array.Empty<object>())?.method_25();

			public NetCacheHeroLevels(IntPtr address, string className)
				: base(address, className)
			{
			}

			public NetCacheHeroLevels(IntPtr address)
				: this(address, "NetCacheHeroLevels")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("NetCache.NetCacheProfileProgress")]
		public class NetCacheProfileProgress : MonoClass
		{
			public TutorialProgress CampaignProgress => method_11<TutorialProgress>("get_CampaignProgress", Array.Empty<object>());

			public int BestForgeWins => method_11<int>("get_BestForgeWins", Array.Empty<object>());

			public long LastForgeDate => method_11<long>("get_LastForgeDate", Array.Empty<object>());

			public int DisplayBanner => method_11<int>("get_DisplayBanner", Array.Empty<object>());

			public NetCacheProfileProgress(IntPtr address, string className)
				: base(address, className)
			{
			}

			public NetCacheProfileProgress(IntPtr address)
				: this(address, "NetCacheProfileProgress")
			{
			}
		}

		[Attribute38("NetCache.NetCacheCardBacks")]
		public class NetCacheCardBacks : MonoClass
		{
			public int DefaultCardBack => method_11<int>("get_DefaultCardBack", Array.Empty<object>());

			public NetCacheCardBacks(IntPtr address, string className)
				: base(address, className)
			{
			}

			public NetCacheCardBacks(IntPtr address)
				: this(address, "NetCacheCardBacks")
			{
			}
		}

		[Attribute38("NetCache.BoosterStack")]
		public class BoosterStack : MonoClass
		{
			public int Id => method_11<int>("get_Id", Array.Empty<object>());

			public int Count => method_11<int>("get_Count", Array.Empty<object>());

			public int LocallyPreConsumedCount => method_11<int>("get_LocallyPreConsumedCount", Array.Empty<object>());

			public BoosterStack(IntPtr address, string className)
				: base(address, className)
			{
			}

			public BoosterStack(IntPtr address)
				: this(address, "BoosterStack")
			{
			}
		}

		[Attribute38("NetCache.NetCacheBoosters")]
		public class NetCacheBoosters : MonoClass
		{
			public List<BoosterStack> BoosterStacks => method_14<Class271<BoosterStack>>("get_BoosterStacks", Array.Empty<object>())?.method_25();

			public NetCacheBoosters(IntPtr address, string className)
				: base(address, className)
			{
			}

			public NetCacheBoosters(IntPtr address)
				: this(address, "NetCacheBoosters")
			{
			}

			public BoosterStack GetBoosterStack(int id)
			{
				return method_14<BoosterStack>("GetBoosterStack", new object[1] { id });
			}

			public int GetTotalNumBoosters()
			{
				return method_11<int>("GetTotalNumBoosters", Array.Empty<object>());
			}
		}

		[Attribute38("NetCache.DeckHeader")]
		public class DeckHeader : MonoClass
		{
			public long ID => method_11<long>("get_ID", Array.Empty<object>());

			public string Name => method_13("get_Name");

			public int CardBack => method_11<int>("get_CardBack", Array.Empty<object>());

			public string Hero => method_13("get_Hero");

			public TAG_PREMIUM HeroPremium => method_11<TAG_PREMIUM>("get_HeroPremium", Array.Empty<object>());

			public string HeroPower => method_13("get_HeroPower");

			public bool CardBackOverridden => method_11<bool>("get_CardBackOverridden", Array.Empty<object>());

			public bool HeroOverridden => method_11<bool>("get_HeroOverridden", Array.Empty<object>());

			public int SeasonId => method_11<int>("get_SeasonId", Array.Empty<object>());

			public bool NeedsName => method_11<bool>("get_NeedsName", Array.Empty<object>());

			public long SortOrder => method_11<long>("get_SortOrder", Array.Empty<object>());

			public bool IsWild => method_11<bool>("get_IsWild", Array.Empty<object>());

			public bool Locked => method_11<bool>("get_Locked", Array.Empty<object>());

			public DeckHeader(IntPtr address, string className)
				: base(address, className)
			{
			}

			public DeckHeader(IntPtr address)
				: this(address, "DeckHeader")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("NetCache.NetCacheDecks")]
		public class NetCacheDecks : MonoClass
		{
			public List<DeckHeader> Decks => method_14<Class271<DeckHeader>>("get_Decks", Array.Empty<object>())?.method_25();

			public NetCacheDecks(IntPtr address, string className)
				: base(address, className)
			{
			}

			public NetCacheDecks(IntPtr address)
				: this(address, "NetCacheDecks")
			{
			}
		}

		[Attribute38("NetCache.CardDefinition")]
		public class CardDefinition : MonoClass
		{
			public string Name => method_13("get_Name");

			public TAG_PREMIUM Premium => method_11<TAG_PREMIUM>("get_Premium", Array.Empty<object>());

			public CardDefinition(IntPtr address, string className)
				: base(address, className)
			{
			}

			public CardDefinition(IntPtr address)
				: this(address, "CardDefinition")
			{
			}

			public new bool Equals(object obj)
			{
				return method_11<bool>("Equals", new object[1] { obj });
			}

			public new int GetHashCode()
			{
				return method_11<int>("GetHashCode", Array.Empty<object>());
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("NetCache.CardValue")]
		public class CardValue : MonoClass
		{
			public int Buy => method_11<int>("get_Buy", Array.Empty<object>());

			public int Sell => method_11<int>("get_Sell", Array.Empty<object>());

			public bool Nerfed => method_11<bool>("get_Nerfed", Array.Empty<object>());

			public CardValue(IntPtr address, string className)
				: base(address, className)
			{
			}

			public CardValue(IntPtr address)
				: this(address, "CardValue")
			{
			}
		}

		[Attribute38("NetCache.NetCacheCardValues")]
		public class NetCacheCardValues : MonoClass
		{
			public int CardNerfIndex => method_11<int>("get_CardNerfIndex", Array.Empty<object>());

			public NetCacheCardValues(IntPtr address, string className)
				: base(address, className)
			{
			}

			public NetCacheCardValues(IntPtr address)
				: this(address, "NetCacheCardValues")
			{
			}
		}

		[Attribute38("NetCache.NetCacheDisconnectedGame")]
		public class NetCacheDisconnectedGame : MonoClass
		{
			public GameType GameType => method_11<GameType>("get_GameType", Array.Empty<object>());

			public NetCacheDisconnectedGame(IntPtr address, string className)
				: base(address, className)
			{
			}

			public NetCacheDisconnectedGame(IntPtr address)
				: this(address, "NetCacheDisconnectedGame")
			{
			}
		}

		[Attribute38("NetCache.BoosterCard")]
		public class BoosterCard : MonoClass
		{
			public CardDefinition Def => method_14<CardDefinition>("get_Def", Array.Empty<object>());

			public long Date => method_11<long>("get_Date", Array.Empty<object>());

			public BoosterCard(IntPtr address, string className)
				: base(address, className)
			{
			}

			public BoosterCard(IntPtr address)
				: this(address, "BoosterCard")
			{
			}
		}

		[Attribute38("NetCache.CardStack")]
		public class CardStack : MonoClass
		{
			public CardDefinition Def => method_14<CardDefinition>("get_Def", Array.Empty<object>());

			public long Date => method_11<long>("get_Date", Array.Empty<object>());

			public int Count => method_11<int>("get_Count", Array.Empty<object>());

			public int NumSeen => method_11<int>("get_NumSeen", Array.Empty<object>());

			public CardStack(IntPtr address, string className)
				: base(address, className)
			{
			}

			public CardStack(IntPtr address)
				: this(address, "CardStack")
			{
			}
		}

		[Attribute38("NetCache.NetCacheCollection")]
		public class NetCacheCollection : MonoClass
		{
			public int TotalCardsOwned => method_2<int>("TotalCardsOwned");

			public List<CardStack> Stacks => method_14<Class271<CardStack>>("get_Stacks", Array.Empty<object>())?.method_25();

			public NetCacheCollection(IntPtr address, string className)
				: base(address, className)
			{
			}

			public NetCacheCollection(IntPtr address)
				: this(address, "NetCacheCollection")
			{
			}
		}

		[Attribute38("NetCache.PlayerRecord")]
		public class PlayerRecord : MonoClass
		{
			public GameType RecordType => method_11<GameType>("get_RecordType", Array.Empty<object>());

			public int Data => method_11<int>("get_Data", Array.Empty<object>());

			public int Wins => method_11<int>("get_Wins", Array.Empty<object>());

			public int Losses => method_11<int>("get_Losses", Array.Empty<object>());

			public int Ties => method_11<int>("get_Ties", Array.Empty<object>());

			public PlayerRecord(IntPtr address, string className)
				: base(address, className)
			{
			}

			public PlayerRecord(IntPtr address)
				: this(address, "PlayerRecord")
			{
			}
		}

		[Attribute38("NetCache.NetCachePlayerRecords")]
		public class NetCachePlayerRecords : MonoClass
		{
			public List<PlayerRecord> Records => method_14<Class271<PlayerRecord>>("get_Records", Array.Empty<object>())?.method_25();

			public NetCachePlayerRecords(IntPtr address, string className)
				: base(address, className)
			{
			}

			public NetCachePlayerRecords(IntPtr address)
				: this(address, "NetCachePlayerRecords")
			{
			}
		}

		[Attribute38("NetCache.NetCacheRewardProgress")]
		public class NetCacheRewardProgress : MonoClass
		{
			public int Season => method_11<int>("get_Season", Array.Empty<object>());

			public long SeasonEndDate => method_11<long>("get_SeasonEndDate", Array.Empty<object>());

			public long NextQuestCancelDate => method_11<long>("get_NextQuestCancelDate", Array.Empty<object>());

			public NetCacheRewardProgress(IntPtr address, string className)
				: base(address, className)
			{
			}

			public NetCacheRewardProgress(IntPtr address)
				: this(address, "NetCacheRewardProgress")
			{
			}
		}

		[Attribute38("NetCache.NetCacheMedalInfo")]
		public class NetCacheMedalInfo : MonoClass
		{
			public NetCacheMedalInfo PreviousMedalInfo => method_14<NetCacheMedalInfo>("get_PreviousMedalInfo", Array.Empty<object>());

			public NetCacheMedalInfo(IntPtr address, string className)
				: base(address, className)
			{
			}

			public NetCacheMedalInfo(IntPtr address)
				: this(address, "NetCacheMedalInfo")
			{
			}

			public NetCacheMedalInfo Clone()
			{
				return method_14<NetCacheMedalInfo>("Clone", Array.Empty<object>());
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("NetCache.ProfileNotice")]
		public class ProfileNotice : MonoClass
		{
			public enum NoticeType
			{
				GAINED_MEDAL = 1,
				REWARD_BOOSTER = 2,
				REWARD_CARD = 3,
				DISCONNECTED_GAME = 4,
				PRECON_DECK = 5,
				REWARD_DUST = 6,
				REWARD_MOUNT = 7,
				REWARD_FORGE = 8,
				REWARD_GOLD = 9,
				PURCHASE = 10,
				REWARD_CARD_BACK = 11,
				BONUS_STARS = 12,
				ADVENTURE_PROGRESS = 14,
				HERO_LEVEL_UP = 0xF,
				ACCOUNT_LICENSE = 0x10,
				TAVERN_BRAWL_REWARDS = 17,
				TAVERN_BRAWL_TICKET = 18,
				EVENT = 19,
				GENERIC_REWARD_CHEST = 20
			}

			public enum NoticeOrigin
			{
				UNKNOWN = -1,
				SEASON = 1,
				BETA_REIMBURSE = 2,
				FORGE = 3,
				TOURNEY = 4,
				PRECON_DECK = 5,
				ACK = 6,
				ACHIEVEMENT = 7,
				LEVEL_UP = 8,
				PURCHASE_COMPLETE = 10,
				PURCHASE_FAILED = 11,
				PURCHASE_CANCELED = 12,
				BLIZZCON = 13,
				EVENT = 14,
				DISCONNECTED_GAME = 0xF,
				OUT_OF_BAND_LICENSE = 0x10,
				IGR = 17,
				ADVENTURE_PROGRESS = 18,
				ADVENTURE_FLAGS = 19,
				TAVERN_BRAWL_REWARD = 20,
				ACCOUNT_LICENSE_FLAGS = 21,
				FROM_PURCHASE = 22,
				HOF_COMPENSATION = 23,
				GENERIC_REWARD_CHEST_ACHIEVE = 24,
				GENERIC_REWARD_CHEST = 25
			}

			public NoticeType m_type => method_2<NoticeType>("m_type");

			public long NoticeID => method_11<long>("get_NoticeID", Array.Empty<object>());

			public NoticeType Type => method_11<NoticeType>("get_Type", Array.Empty<object>());

			public NoticeOrigin Origin => method_11<NoticeOrigin>("get_Origin", Array.Empty<object>());

			public long OriginData => method_11<long>("get_OriginData", Array.Empty<object>());

			public long Date => method_11<long>("get_Date", Array.Empty<object>());

			public ProfileNotice(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ProfileNotice(IntPtr address)
				: this(address, "ProfileNotice")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("NetCache.ProfileNoticeMedal")]
		public class ProfileNoticeMedal : ProfileNotice
		{
			public int StarLevel => method_11<int>("get_StarLevel", Array.Empty<object>());

			public int LegendRank => method_11<int>("get_LegendRank", Array.Empty<object>());

			public int BestStarLevel => method_11<int>("get_BestStarLevel", Array.Empty<object>());

			public bool IsWild => method_11<bool>("get_IsWild", Array.Empty<object>());

			public ProfileNoticeMedal(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ProfileNoticeMedal(IntPtr address)
				: this(address, "ProfileNoticeMedal")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("NetCache.ProfileNoticeRewardBooster")]
		public class ProfileNoticeRewardBooster : ProfileNotice
		{
			public int Id => method_11<int>("get_Id", Array.Empty<object>());

			public int Count => method_11<int>("get_Count", Array.Empty<object>());

			public ProfileNoticeRewardBooster(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ProfileNoticeRewardBooster(IntPtr address)
				: this(address, "ProfileNoticeRewardBooster")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("NetCache.ProfileNoticeRewardCard")]
		public class ProfileNoticeRewardCard : ProfileNotice
		{
			public string CardID => method_13("get_CardID");

			public TAG_PREMIUM Premium => method_11<TAG_PREMIUM>("get_Premium", Array.Empty<object>());

			public int Quantity => method_11<int>("get_Quantity", Array.Empty<object>());

			public ProfileNoticeRewardCard(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ProfileNoticeRewardCard(IntPtr address)
				: this(address, "ProfileNoticeRewardCard")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("NetCache.ProfileNoticePreconDeck")]
		public class ProfileNoticePreconDeck : ProfileNotice
		{
			public long DeckID => method_11<long>("get_DeckID", Array.Empty<object>());

			public int HeroAsset => method_11<int>("get_HeroAsset", Array.Empty<object>());

			public ProfileNoticePreconDeck(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ProfileNoticePreconDeck(IntPtr address)
				: this(address, "ProfileNoticePreconDeck")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("NetCache.ProfileNoticeRewardDust")]
		public class ProfileNoticeRewardDust : ProfileNotice
		{
			public int Amount => method_11<int>("get_Amount", Array.Empty<object>());

			public ProfileNoticeRewardDust(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ProfileNoticeRewardDust(IntPtr address)
				: this(address, "ProfileNoticeRewardDust")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("NetCache.ProfileNoticeRewardMount")]
		public class ProfileNoticeRewardMount : ProfileNotice
		{
			public int MountID => method_11<int>("get_MountID", Array.Empty<object>());

			public ProfileNoticeRewardMount(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ProfileNoticeRewardMount(IntPtr address)
				: this(address, "ProfileNoticeRewardMount")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("NetCache.ProfileNoticeRewardForge")]
		public class ProfileNoticeRewardForge : ProfileNotice
		{
			public int Quantity => method_11<int>("get_Quantity", Array.Empty<object>());

			public ProfileNoticeRewardForge(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ProfileNoticeRewardForge(IntPtr address)
				: this(address, "ProfileNoticeRewardForge")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("NetCache.ProfileNoticeRewardGold")]
		public class ProfileNoticeRewardGold : ProfileNotice
		{
			public int Amount => method_11<int>("get_Amount", Array.Empty<object>());

			public ProfileNoticeRewardGold(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ProfileNoticeRewardGold(IntPtr address)
				: this(address, "ProfileNoticeRewardGold")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("NetCache.ProfileNoticePurchase")]
		public class ProfileNoticePurchase : ProfileNotice
		{
			public string ProductID => method_13("get_ProductID");

			public string CurrencyCode => method_13("get_CurrencyCode");

			public long Data => method_11<long>("get_Data", Array.Empty<object>());

			public ProfileNoticePurchase(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ProfileNoticePurchase(IntPtr address)
				: this(address, "ProfileNoticePurchase")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("NetCache.ProfileNoticeRewardCardBack")]
		public class ProfileNoticeRewardCardBack : ProfileNotice
		{
			public int CardBackID => method_11<int>("get_CardBackID", Array.Empty<object>());

			public ProfileNoticeRewardCardBack(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ProfileNoticeRewardCardBack(IntPtr address)
				: this(address, "ProfileNoticeRewardCardBack")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("NetCache.ProfileNoticeBonusStars")]
		public class ProfileNoticeBonusStars : ProfileNotice
		{
			public int StarLevel => method_11<int>("get_StarLevel", Array.Empty<object>());

			public int Stars => method_11<int>("get_Stars", Array.Empty<object>());

			public ProfileNoticeBonusStars(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ProfileNoticeBonusStars(IntPtr address)
				: this(address, "ProfileNoticeBonusStars")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("NetCache.ProfileNoticeEvent")]
		public class ProfileNoticeEvent : ProfileNotice
		{
			public int EventType => method_11<int>("get_EventType", Array.Empty<object>());

			public ProfileNoticeEvent(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ProfileNoticeEvent(IntPtr address)
				: this(address, "ProfileNoticeEvent")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("NetCache.ProfileNoticeDisconnectedGame")]
		public class ProfileNoticeDisconnectedGame : ProfileNotice
		{
			public GameType GameType => method_11<GameType>("get_GameType", Array.Empty<object>());

			public int MissionId => method_11<int>("get_MissionId", Array.Empty<object>());

			public int PlayerIndex => method_11<int>("get_PlayerIndex", Array.Empty<object>());

			public ProfileNoticeDisconnectedGame(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ProfileNoticeDisconnectedGame(IntPtr address)
				: this(address, "ProfileNoticeDisconnectedGame")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("NetCache.ProfileNoticeAdventureProgress")]
		public class ProfileNoticeAdventureProgress : ProfileNotice
		{
			public int Wing => method_11<int>("get_Wing", Array.Empty<object>());

			public ProfileNoticeAdventureProgress(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ProfileNoticeAdventureProgress(IntPtr address)
				: this(address, "ProfileNoticeAdventureProgress")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("NetCache.ProfileNoticeLevelUp")]
		public class ProfileNoticeLevelUp : ProfileNotice
		{
			public int HeroClass => method_11<int>("get_HeroClass", Array.Empty<object>());

			public int NewLevel => method_11<int>("get_NewLevel", Array.Empty<object>());

			public ProfileNoticeLevelUp(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ProfileNoticeLevelUp(IntPtr address)
				: this(address, "ProfileNoticeLevelUp")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("NetCache.ProfileNoticeAcccountLicense")]
		public class ProfileNoticeAcccountLicense : ProfileNotice
		{
			public long License => method_11<long>("get_License", Array.Empty<object>());

			public long CasID => method_11<long>("get_CasID", Array.Empty<object>());

			public ProfileNoticeAcccountLicense(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ProfileNoticeAcccountLicense(IntPtr address)
				: this(address, "ProfileNoticeAcccountLicense")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("NetCache.ProfileNoticeTavernBrawlRewards")]
		public class ProfileNoticeTavernBrawlRewards : ProfileNotice
		{
			public int Wins => method_11<int>("get_Wins", Array.Empty<object>());

			public ProfileNoticeTavernBrawlRewards(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ProfileNoticeTavernBrawlRewards(IntPtr address)
				: this(address, "ProfileNoticeTavernBrawlRewards")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("NetCache.ProfileNoticeTavernBrawlTicket")]
		public class ProfileNoticeTavernBrawlTicket : ProfileNotice
		{
			public int TicketType => method_11<int>("get_TicketType", Array.Empty<object>());

			public int Quantity => method_11<int>("get_Quantity", Array.Empty<object>());

			public ProfileNoticeTavernBrawlTicket(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ProfileNoticeTavernBrawlTicket(IntPtr address)
				: this(address, "ProfileNoticeTavernBrawlTicket")
			{
			}
		}

		[Attribute38("NetCache.ProfileNoticeGenericRewardChest")]
		public class ProfileNoticeGenericRewardChest : ProfileNotice
		{
			public int RewardChestAssetId => method_11<int>("get_RewardChestAssetId", Array.Empty<object>());

			public uint RewardChestByteSize => method_11<uint>("get_RewardChestByteSize", Array.Empty<object>());

			public List<byte> RewardChestHash => method_14<Class250<byte>>("get_RewardChestHash", Array.Empty<object>())?.method_25();

			public ProfileNoticeGenericRewardChest(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ProfileNoticeGenericRewardChest(IntPtr address)
				: this(address, "ProfileNoticeGenericRewardChest")
			{
			}
		}

		[Attribute38("NetCache.NetCacheProfileNotices")]
		public class NetCacheProfileNotices : MonoClass
		{
			public List<ProfileNotice> Notices => method_14<Class271<ProfileNotice>>("get_Notices", Array.Empty<object>())?.method_25();

			public NetCacheProfileNotices(IntPtr address, string className)
				: base(address, className)
			{
			}

			public NetCacheProfileNotices(IntPtr address)
				: this(address, "NetCacheProfileNotices")
			{
			}
		}

		[Attribute38("NetCache.ClientOptionBase")]
		public class ClientOptionBase : MonoClass
		{
			public ClientOptionBase(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ClientOptionBase(IntPtr address)
				: this(address, "ClientOptionBase")
			{
			}

			public new bool Equals(object other)
			{
				return method_11<bool>("Equals", new object[1] { other });
			}

			public new int GetHashCode()
			{
				return method_11<int>("GetHashCode", Array.Empty<object>());
			}

			public object Clone()
			{
				return method_14<object>("Clone", Array.Empty<object>());
			}
		}

		[Attribute38("NetCache.ClientOptionInt")]
		public class ClientOptionInt : ClientOptionBase
		{
			public int OptionValue => method_11<int>("get_OptionValue", Array.Empty<object>());

			public ClientOptionInt(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ClientOptionInt(IntPtr address)
				: this(address, "ClientOptionInt")
			{
			}

			public new bool Equals(object other)
			{
				return method_11<bool>("Equals", new object[1] { other });
			}

			public new int GetHashCode()
			{
				return method_11<int>("GetHashCode", Array.Empty<object>());
			}
		}

		[Attribute38("NetCache.ClientOptionLong")]
		public class ClientOptionLong : ClientOptionBase
		{
			public long OptionValue => method_11<long>("get_OptionValue", Array.Empty<object>());

			public ClientOptionLong(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ClientOptionLong(IntPtr address)
				: this(address, "ClientOptionLong")
			{
			}

			public new bool Equals(object other)
			{
				return method_11<bool>("Equals", new object[1] { other });
			}

			public new int GetHashCode()
			{
				return method_11<int>("GetHashCode", Array.Empty<object>());
			}
		}

		[Attribute38("NetCache.ClientOptionFloat")]
		public class ClientOptionFloat : ClientOptionBase
		{
			public float OptionValue => method_11<float>("get_OptionValue", Array.Empty<object>());

			public ClientOptionFloat(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ClientOptionFloat(IntPtr address)
				: this(address, "ClientOptionFloat")
			{
			}

			public new bool Equals(object other)
			{
				return method_11<bool>("Equals", new object[1] { other });
			}

			public new int GetHashCode()
			{
				return method_11<int>("GetHashCode", Array.Empty<object>());
			}
		}

		[Attribute38("NetCache.ClientOptionULong")]
		public class ClientOptionULong : ClientOptionBase
		{
			public ulong OptionValue => method_11<ulong>("get_OptionValue", Array.Empty<object>());

			public ClientOptionULong(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ClientOptionULong(IntPtr address)
				: this(address, "ClientOptionULong")
			{
			}

			public new bool Equals(object other)
			{
				return method_11<bool>("Equals", new object[1] { other });
			}

			public new int GetHashCode()
			{
				return method_11<int>("GetHashCode", Array.Empty<object>());
			}
		}

		[Attribute38("NetCache.NetCacheClientOptions")]
		public class NetCacheClientOptions : MonoClass
		{
			public NetCacheClientOptions(IntPtr address, string className)
				: base(address, className)
			{
			}

			public NetCacheClientOptions(IntPtr address)
				: this(address, "NetCacheClientOptions")
			{
			}

			public void UpdateServerState()
			{
				method_8("UpdateServerState");
			}

			public void OnUpdateIntervalElasped(object userData)
			{
				method_8("OnUpdateIntervalElasped", userData);
			}

			public void DispatchClientOptionsToServer()
			{
				method_8("DispatchClientOptionsToServer");
			}

			public void RemoveInvalidOptions()
			{
				method_8("RemoveInvalidOptions");
			}
		}

		[Attribute38("NetCache.NetCacheFavoriteHeroes")]
		public class NetCacheFavoriteHeroes : MonoClass
		{
			public NetCacheFavoriteHeroes(IntPtr address, string className)
				: base(address, className)
			{
			}

			public NetCacheFavoriteHeroes(IntPtr address)
				: this(address, "NetCacheFavoriteHeroes")
			{
			}
		}

		[Attribute38("NetCache.NetCacheAccountLicenses")]
		public class NetCacheAccountLicenses : MonoClass
		{
			public NetCacheAccountLicenses(IntPtr address, string className)
				: base(address, className)
			{
			}

			public NetCacheAccountLicenses(IntPtr address)
				: this(address, "NetCacheAccountLicenses")
			{
			}
		}

		public enum ErrorCode
		{
			NONE,
			TIMEOUT,
			SERVER
		}

		[Attribute38("NetCache.ErrorInfo")]
		public class ErrorInfo : MonoClass
		{
			public ErrorCode Error => method_11<ErrorCode>("get_Error", Array.Empty<object>());

			public uint ServerError => method_11<uint>("get_ServerError", Array.Empty<object>());

			public string RequestStackTrace => method_13("get_RequestStackTrace");

			public ErrorInfo(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ErrorInfo(IntPtr address)
				: this(address, "ErrorInfo")
			{
			}
		}

		public enum RequestResult
		{
			UNKNOWN,
			PENDING,
			IN_PROCESS,
			GENERIC_COMPLETE,
			DATA_COMPLETE,
			ERROR
		}

		[Attribute38("NetCache.Request")]
		public class Request : MonoClass
		{
			public static bool RELOAD => MonoClass.smethod_6<bool>(TritonHs.MainAssemblyPath, "", "NetCache/Request", "RELOAD");

			public Type m_type => method_3<Type>("m_type");

			public bool m_reload => method_2<bool>("m_reload");

			public RequestResult m_result => method_2<RequestResult>("m_result");

			public Request(IntPtr address, string className)
				: base(address, className)
			{
			}

			public Request(IntPtr address)
				: this(address, "Request")
			{
			}
		}

		[Attribute38("NetCache.NetCacheBatchRequest")]
		public class NetCacheBatchRequest : MonoClass
		{
			public bool m_canTimeout => method_2<bool>("m_canTimeout");

			public DateTime m_timeAdded => method_2<DateTime>("m_timeAdded");

			public string m_requestStackTrace => method_4("m_requestStackTrace");

			public NetCacheBatchRequest(IntPtr address, string className)
				: base(address, className)
			{
			}

			public NetCacheBatchRequest(IntPtr address)
				: this(address, "NetCacheBatchRequest")
			{
			}

			public void AddRequest(Request r)
			{
				method_8("AddRequest", r);
			}
		}

		public static List<Type> m_ServerInitiatedAccountInfoTypes => MonoClass.smethod_7<Class271<Type>>(TritonHs.MainAssemblyPath, "", "NetCache", "m_ServerInitiatedAccountInfoTypes")?.method_25();

		public NetCacheHeroLevels m_prevHeroLevels => method_3<NetCacheHeroLevels>("m_prevHeroLevels");

		public NetCacheMedalInfo m_previousMedalInfo => method_3<NetCacheMedalInfo>("m_previousMedalInfo");

		public List<ProfileNotice> m_queuedProfileNotices => method_3<Class271<ProfileNotice>>("m_queuedProfileNotices")?.method_25();

		public bool m_receivedInitialProfileNotices => method_2<bool>("m_receivedInitialProfileNotices");

		public long m_currencyVersion => method_2<long>("m_currencyVersion");

		public long m_initialCollectionVersion => method_2<long>("m_initialCollectionVersion");

		public long m_lastForceCheckedSeason => method_2<long>("m_lastForceCheckedSeason");

		public List<NetCacheBatchRequest> m_cacheRequests => method_3<Class271<NetCacheBatchRequest>>("m_cacheRequests")?.method_25();

		public List<Type> m_inTransitRequests => method_3<Class271<Type>>("m_inTransitRequests")?.method_25();

		public static bool m_fatalErrorCodeSet => MonoClass.smethod_6<bool>(TritonHs.MainAssemblyPath, "", "NetCache", "m_fatalErrorCodeSet");

		public NetCache(IntPtr address, string className)
			: base(address, className)
		{
		}

		public NetCache(IntPtr address)
			: this(address, "NetCache")
		{
		}

		public static void DefaultErrorHandler(ErrorInfo info)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "NetCache", "DefaultErrorHandler", info);
		}

		public static string GetInternalErrorMessage(ErrorInfo info, bool includeStackTrace)
		{
			return MonoClass.smethod_12(TritonHs.MainAssemblyPath, "", "NetCache", "GetInternalErrorMessage", info, includeStackTrace);
		}

		public static NetCache Get()
		{
			return MonoClass.smethod_15<NetCache>(TritonHs.MainAssemblyPath, "", "NetCache", "Get", Array.Empty<object>());
		}

		public static void NetCache_WillReset()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "NetCache", "NetCache_WillReset");
		}

		public object GetTestData(Type type)
		{
			return method_14<object>("GetTestData", new object[1] { type });
		}

		public long GetArcaneDustBalance()
		{
			return method_11<long>("GetArcaneDustBalance", Array.Empty<object>());
		}

		public long GetGoldBalance()
		{
			return method_11<long>("GetGoldBalance", Array.Empty<object>());
		}

		public int GetArenaTicketBalance()
		{
			return method_11<int>("GetArenaTicketBalance", Array.Empty<object>());
		}

		public int GetIntOption(ServerOption type)
		{
			return method_10<int>("GetIntOption", new Class276.Enum20[1] { Class276.Enum20.ValueType }, new object[1] { type });
		}

		public long GetLongOption(ServerOption type)
		{
			return method_10<long>("GetLongOption", new Class276.Enum20[1] { Class276.Enum20.ValueType }, new object[1] { type });
		}

		public float GetFloatOption(ServerOption type)
		{
			return method_10<float>("GetFloatOption", new Class276.Enum20[1] { Class276.Enum20.ValueType }, new object[1] { type });
		}

		public ulong GetULongOption(ServerOption type)
		{
			return method_10<ulong>("GetULongOption", new Class276.Enum20[1] { Class276.Enum20.ValueType }, new object[1] { type });
		}

		public bool RemoveNotice(long ID)
		{
			return method_11<bool>("RemoveNotice", new object[1] { ID });
		}

		public void CheckSeasonForRoll()
		{
			method_8("CheckSeasonForRoll");
		}

		public void NetCacheMakeBatchRequest(NetCacheBatchRequest batchRequest)
		{
			method_8("NetCacheMakeBatchRequest", batchRequest);
		}

		public void NetCacheUse_Internal(NetCacheBatchRequest request, Type type)
		{
			method_8("NetCacheUse_Internal", request, type);
		}

		public void RequestNetCacheObject(Type type)
		{
			method_8("RequestNetCacheObject", type);
		}

		public void NetCacheReload_Internal(NetCacheBatchRequest request, Type type)
		{
			method_8("NetCacheReload_Internal", request, type);
		}

		public void NetCacheCheckRequest(NetCacheBatchRequest request)
		{
			method_8("NetCacheCheckRequest", request);
		}

		public void UpdateRequestNeedState(Type type, RequestResult result)
		{
			method_8("UpdateRequestNeedState", type, result);
		}

		public void Clear()
		{
			method_8("Clear");
		}

		public void Heartbeat()
		{
			method_8("Heartbeat");
		}

		public void OnGenericResponse()
		{
			method_8("OnGenericResponse");
		}

		public void OnDBAction()
		{
			method_8("OnDBAction");
		}

		public void FakeInitialClientState()
		{
			method_8("FakeInitialClientState");
		}

		public void OnInitialClientState()
		{
			method_8("OnInitialClientState");
		}

		public void OnDecks()
		{
			method_8("OnDecks");
		}

		public void OnCardValues()
		{
			method_8("OnCardValues");
		}

		public void OnMedalInfo()
		{
			method_8("OnMedalInfo");
		}

		public void OnGuardianVars()
		{
			method_9("OnGuardianVars", new Class276.Enum20[0]);
		}

		public bool AddExpectedCollectionModification(long version)
		{
			return method_11<bool>("AddExpectedCollectionModification", new object[1] { version });
		}

		public void OnGamesInfo()
		{
			method_8("OnGamesInfo");
		}

		public void OnProfileProgress()
		{
			method_8("OnProfileProgress");
		}

		public void OnHearthstoneUnavailableGame()
		{
			method_8("OnHearthstoneUnavailableGame");
		}

		public void OnHearthstoneUnavailableUtil()
		{
			method_8("OnHearthstoneUnavailableUtil");
		}

		public void OnHearthstoneUnavailable(bool gamePacket)
		{
			method_8("OnHearthstoneUnavailable", gamePacket);
		}

		public void OnPlayQueue()
		{
			method_8("OnPlayQueue");
		}

		public void OnCardBacks()
		{
			method_8("OnCardBacks");
		}

		public void OnPlayerRecords()
		{
			method_8("OnPlayerRecords");
		}

		public void OnRewardProgress()
		{
			method_8("OnRewardProgress");
		}

		public void OnAllHeroXP()
		{
			method_8("OnAllHeroXP");
		}

		public void SetClientOption(ServerOption type, ClientOptionBase newVal)
		{
			method_8("SetClientOption", type, newVal);
		}

		public void SetIntOption(ServerOption type, int val)
		{
			method_8("SetIntOption", type, val);
		}

		public void SetLongOption(ServerOption type, long val)
		{
			method_8("SetLongOption", type, val);
		}

		public void SetFloatOption(ServerOption type, float val)
		{
			method_8("SetFloatOption", type, val);
		}

		public void SetULongOption(ServerOption type, ulong val)
		{
			method_8("SetULongOption", type, val);
		}

		public void DeleteClientOption(ServerOption type)
		{
			method_8("DeleteClientOption", type);
		}

		public bool ClientOptionExists(ServerOption type)
		{
			return method_11<bool>("ClientOptionExists", new object[1] { type });
		}

		public void DispatchClientOptionsToServer()
		{
			method_8("DispatchClientOptionsToServer");
		}

		public void OnFavoriteHeroesResponse()
		{
			method_8("OnFavoriteHeroesResponse");
		}

		public void OnAccountLicensesInfoResponse()
		{
			method_8("OnAccountLicensesInfoResponse");
		}

		public void OnClientStaticAssetsResponse()
		{
			method_8("OnClientStaticAssetsResponse");
		}

		public void OnFSGFeatureConfig()
		{
			method_8("OnFSGFeatureConfig");
		}

		public void RegisterNetCacheHandlers()
		{
			method_8("RegisterNetCacheHandlers");
		}

		public void InitNetCache()
		{
			method_8("InitNetCache");
		}

		public void OnPacketThrottled(int packetID, long retryMillis)
		{
			method_8("OnPacketThrottled", packetID, retryMillis);
		}

		public void Cheat_AddNotice(ProfileNotice notice)
		{
			method_8("Cheat_AddNotice", notice);
		}
	}
}
